home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 1 / BBS in a box - Trilogy I.iso / Files / Publish / Photoshop / Plug-in Modules / Code / PIUtilities.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-28  |  8.9 KB  |  468 lines  |  [TEXT/MPS ]
  1. /*
  2.     File: PIUtilities.c
  3.  
  4.     Copyright 1993 by Adobe Systems, Inc.
  5.  
  6.     C source file for plug-in callback utilities.
  7. */
  8.  
  9. #include <Types.h>
  10.  
  11. #include "PIUtilities.h"
  12.  
  13. #include "PITypes.h"
  14. #include "PIGeneral.h"
  15.  
  16. /*****************************************************************************/
  17.  
  18. Boolean HostBufferProcsAvailable (BufferProcs *procs, Boolean *tooNew)
  19.     {
  20.     
  21.     Boolean available = TRUE;
  22.     Boolean myTooNew = FALSE;
  23.     
  24.     if (!procs)
  25.         available = FALSE;
  26.         
  27.     else if (procs->bufferProcsVersion < kCurrentBufferProcsVersion)
  28.         available = FALSE;
  29.         
  30.     else if (procs->bufferProcsVersion > kCurrentBufferProcsVersion)
  31.         {
  32.         
  33.         available = FALSE;
  34.         
  35.         myTooNew = TRUE;
  36.         
  37.         }
  38.         
  39.     else if (procs->numBufferProcs < kCurrentBufferProcsCount ||
  40.              !procs->allocateProc ||
  41.              !procs->lockProc ||
  42.              !procs->unlockProc ||
  43.              !procs->freeProc ||
  44.              !procs->spaceProc)
  45.         available = FALSE;
  46.         
  47.     if (tooNew)
  48.         *tooNew = myTooNew;
  49.         
  50.     return available;
  51.     
  52.     }
  53.  
  54. /*****************************************************************************/
  55.  
  56. Boolean WarnHostBufferProcsAvailable (BufferProcs *procs)
  57.     {
  58.     
  59.     #define tooOldID 16997
  60.     #define tooNewID 16998
  61.     
  62.     Boolean available, tooNew;
  63.     
  64.     available = HostBufferProcsAvailable (procs, &tooNew);
  65.     
  66.     if (!available)
  67.         ShowAlert (tooNew ? tooNewID : tooOldID);
  68.         
  69.     return available;
  70.     
  71.     #undef tooOldID
  72.     #undef tooNewID
  73.     
  74.     }
  75.  
  76. /*****************************************************************************/
  77.  
  78. int32 HostBufferSpace (BufferProcs *procs)
  79.     {
  80.     
  81.     if (!HostBufferProcsAvailable (procs, NULL))
  82.         return 0;
  83.         
  84.     else
  85.         return (*procs->spaceProc) ();
  86.     
  87.     }
  88.  
  89. /*****************************************************************************/
  90.  
  91. OSErr HostAllocateBuffer (BufferProcs *procs, int32 size, BufferID *bufferID)
  92.     {
  93.     
  94.     *bufferID = 0;
  95.     
  96.     if (!HostBufferProcsAvailable (procs, NULL))
  97.         return memFullErr;
  98.         
  99.     else
  100.         return (*procs->allocateProc) (size, bufferID);
  101.     
  102.     }
  103.  
  104. /*****************************************************************************/
  105.  
  106. void HostFreeBuffer (BufferProcs *procs, BufferID bufferID)
  107.     {
  108.     
  109.     if (HostBufferProcsAvailable (procs, NULL))
  110.         (*procs->freeProc) (bufferID);
  111.     
  112.     }
  113.  
  114. /*****************************************************************************/
  115.  
  116. Ptr HostLockBuffer (BufferProcs *procs, BufferID bufferID, Boolean moveHigh)
  117.     {
  118.     
  119.     if (HostBufferProcsAvailable (procs, NULL))
  120.         return (*procs->lockProc) (bufferID, moveHigh);
  121.     else
  122.         return NULL;
  123.     
  124.     }
  125.  
  126. /*****************************************************************************/
  127.  
  128. void HostUnlockBuffer (BufferProcs *procs, BufferID bufferID)
  129.     {
  130.     
  131.     if (HostBufferProcsAvailable (procs, NULL))
  132.         (*procs->unlockProc) (bufferID);
  133.     
  134.     }
  135.  
  136. /*****************************************************************************/
  137.  
  138. OSErr HostAllocateStripBuffer (BufferProcs *procs,
  139.                                int32 rowBytes,
  140.                                int16 minHeight,
  141.                                int16 maxHeight,
  142.                                int16 numBuffers,
  143.                                int16 *actualHeight,
  144.                                BufferID *bufferID)
  145.     {
  146.     
  147.     int16 curHeight;
  148.     int32 curSize;
  149.     OSErr curResult = noErr;
  150.     int32 availableSpace = HostBufferSpace (procs) / numBuffers;
  151.     
  152.     int32 availableHeight = availableSpace / rowBytes;
  153.     
  154.     curHeight = (availableHeight < maxHeight) ? (int16) availableHeight
  155.                                               : maxHeight;
  156.                                               
  157.     ++curHeight;
  158.     
  159.     curSize = rowBytes * (int32) curHeight;
  160.     
  161.     *bufferID = 0;
  162.     
  163.     while (!*bufferID && curHeight > minHeight)
  164.         {
  165.         
  166.         --curHeight;
  167.         curSize -= rowBytes;
  168.         
  169.         curResult = HostAllocateBuffer (procs, curSize, bufferID);
  170.         
  171.         }
  172.         
  173.     if (*bufferID)
  174.         *actualHeight = curHeight;
  175.         
  176.     return curResult;
  177.     
  178.     }
  179.  
  180. /*****************************************************************************/
  181.  
  182. Boolean HostResourceProcsAvailable (ResourceProcs *procs, Boolean *tooNew)
  183.     {
  184.     
  185.     Boolean available = TRUE;
  186.     Boolean myTooNew = FALSE;
  187.     
  188.     if (!procs)
  189.         available = FALSE;
  190.         
  191.     else if (procs->resourceProcsVersion < kCurrentResourceProcsVersion)
  192.         available = FALSE;
  193.         
  194.     else if (procs->resourceProcsVersion > kCurrentResourceProcsVersion)
  195.         {
  196.         
  197.         available = FALSE;
  198.         
  199.         myTooNew = TRUE;
  200.         
  201.         }
  202.         
  203.     else if (procs->numResourceProcs < kCurrentResourceProcsCount ||
  204.              !procs->countProc ||
  205.              !procs->getProc ||
  206.              !procs->deleteProc ||
  207.              !procs->addProc)
  208.         available = FALSE;
  209.         
  210.     if (tooNew)
  211.         *tooNew = myTooNew;
  212.         
  213.     return available;
  214.     
  215.     }
  216.  
  217. /*****************************************************************************/
  218.  
  219. Boolean WarnHostResourceProcsAvailable (ResourceProcs *procs)
  220.     {
  221.     
  222.     #define tooOldID 16999
  223.     #define tooNewID 16998
  224.     
  225.     Boolean available, tooNew;
  226.     
  227.     available = HostResourceProcsAvailable (procs, &tooNew);
  228.     
  229.     if (!available)
  230.         ShowAlert (tooNew ? tooNewID : tooOldID);
  231.         
  232.     return available;
  233.     
  234.     #undef tooOldID
  235.     #undef tooNewID
  236.     
  237.     }
  238.  
  239. /*****************************************************************************/
  240.  
  241. int16 HostCountPIResources (ResourceProcs *procs, ResType type)
  242.     {
  243.     
  244.     if (!HostResourceProcsAvailable (procs, NULL))
  245.         return 0;
  246.         
  247.     else
  248.         return (*procs->countProc) (type);
  249.     
  250.     }
  251.  
  252. /*****************************************************************************/
  253.  
  254. Handle HostGetPIResource (ResourceProcs *procs, ResType type, int16 index)
  255.     {
  256.     
  257.     if (!HostResourceProcsAvailable (procs, NULL))
  258.         return NULL;
  259.         
  260.     else
  261.         return (*procs->getProc) (type, index);
  262.     
  263.     }
  264.  
  265. /*****************************************************************************/
  266.  
  267. void HostDeletePIResource (ResourceProcs *procs, ResType type, int16 index)
  268.     {
  269.     
  270.     if (HostResourceProcsAvailable (procs, NULL))
  271.         (*procs->deleteProc) (type, index);
  272.     
  273.     }
  274.  
  275. /*****************************************************************************/
  276.  
  277. OSErr HostAddPIResource (ResourceProcs *procs, ResType type, Handle data)
  278.     {
  279.     
  280.     if (!HostResourceProcsAvailable (procs, NULL))
  281.         return memFullErr;
  282.         
  283.     else
  284.         return (*procs->addProc) (type, data);
  285.     
  286.     }
  287.  
  288. /*****************************************************************************/
  289.  
  290. Boolean HostHandleProcsAvailable (HandleProcs *procs, Boolean *tooNew)
  291.     {
  292.     
  293.     /* We only require the new, dispose, set size, and get size procs. */
  294.     /* Lock and unlock can usually be gotten around without resorting  */
  295.     /* to callbacks.                                                   */
  296.     
  297.     #define kCoreHandleProcsCount 4
  298.     
  299.     Boolean available = TRUE;
  300.     Boolean myTooNew = FALSE;
  301.     
  302.     if (!procs)
  303.         available = FALSE;
  304.         
  305.     else if (procs->handleProcsVersion < kCurrentHandleProcsVersion)
  306.         available = FALSE;
  307.         
  308.     else if (procs->handleProcsVersion > kCurrentHandleProcsVersion)
  309.         {
  310.         
  311.         available = FALSE;
  312.         
  313.         myTooNew = TRUE;
  314.         
  315.         }
  316.         
  317.     else if (procs->numHandleProcs < kCoreHandleProcsCount ||
  318.              !procs->newProc ||
  319.              !procs->disposeProc ||
  320.              !procs->getSizeProc ||
  321.              !procs->setSizeProc)
  322.         available = FALSE;
  323.         
  324.     if (tooNew)
  325.         *tooNew = myTooNew;
  326.         
  327.     return available;
  328.     
  329.     }
  330.  
  331. /*****************************************************************************/
  332.  
  333. Boolean WarnHostHandleProcsAvailable (HandleProcs *procs)
  334.     {
  335.     
  336.     #define tooOldID 16999
  337.     #define tooNewID 16998
  338.     
  339.     Boolean available, tooNew;
  340.     
  341.     available = HostHandleProcsAvailable (procs, &tooNew);
  342.     
  343.     if (!available)
  344.         ShowAlert (tooNew ? tooNewID : tooOldID);
  345.         
  346.     return available;
  347.     
  348.     #undef tooOldID
  349.     #undef tooNewID
  350.     
  351.     }
  352.  
  353. /*****************************************************************************/
  354.  
  355. Handle HostNewHandle (HandleProcs *procs, int32 size)
  356.     {
  357.     
  358.     if (!HostHandleProcsAvailable (procs, NULL))
  359.         return NewHandle (size);
  360.         
  361.     else
  362.         return (*procs->newProc) (size);
  363.     
  364.     }
  365.  
  366. /*****************************************************************************/
  367.  
  368. void HostDisposeHandle (HandleProcs *procs, Handle h)
  369.     {
  370.     
  371.     if (!HostHandleProcsAvailable (procs, NULL))
  372.         DisposHandle (h);
  373.         
  374.     else
  375.         (*procs->disposeProc) (h);
  376.     
  377.     }
  378.  
  379. /*****************************************************************************/
  380.  
  381. int32 HostGetHandleSize (HandleProcs *procs, Handle h)
  382.     {
  383.     
  384.     if (!HostHandleProcsAvailable (procs, NULL))
  385.         return GetHandleSize (h);
  386.         
  387.     else
  388.         return (*procs->getSizeProc) (h);
  389.     
  390.     }
  391.  
  392. /*****************************************************************************/
  393.  
  394. OSErr HostSetHandleSize (HandleProcs *procs, Handle h, int32 newSize)
  395.     {
  396.     
  397.     if (!HostHandleProcsAvailable (procs, NULL))
  398.         {
  399.         
  400.         SetHandleSize (h, newSize);
  401.         
  402.         return MemError ();
  403.         
  404.         }
  405.         
  406.     else
  407.         return (*procs->setSizeProc) (h, newSize);
  408.     
  409.     }
  410.  
  411. /*****************************************************************************/
  412.  
  413. Ptr HostLockHandle (HandleProcs *procs, Handle h, Boolean moveHigh)
  414.     {
  415.     
  416.     if (procs &&
  417.         procs->handleProcsVersion == kCurrentHandleProcsVersion &&
  418.         procs->numHandleProcs >= 6 &&
  419.         procs->lockProc &&
  420.         procs->unlockProc)
  421.         {
  422.         
  423.         return (*procs->lockProc) (h, moveHigh);
  424.         
  425.         }
  426.         
  427.     else
  428.         {
  429.         
  430.         if (moveHigh)
  431.             MoveHHi (h);
  432.     
  433.         HLock (h);
  434.         
  435.         return *h;
  436.         
  437.         }
  438.     
  439.     }
  440.  
  441. /*****************************************************************************/
  442.  
  443. void HostUnlockHandle (HandleProcs *procs, Handle h)
  444.     {
  445.     
  446.     if (procs &&
  447.         procs->handleProcsVersion == kCurrentHandleProcsVersion &&
  448.         procs->numHandleProcs >= 6 &&
  449.         procs->lockProc &&
  450.         procs->unlockProc)
  451.         {
  452.         
  453.         (*procs->unlockProc) (h);
  454.         
  455.         }
  456.         
  457.     else
  458.         {
  459.     
  460.         HUnlock (h);
  461.         
  462.         }
  463.     
  464.     }
  465.  
  466. /*****************************************************************************/
  467.  
  468.